home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / dev / src / td01_src.lha / td_r0.1 / sl3 / source / rawb / rawb.c next >
Encoding:
C/C++ Source or Header  |  1999-05-16  |  11.4 KB  |  476 lines
  1. /*
  2. **      $VER: rawa.c 1.00 (15.05.1999)
  3. **
  4. **      Creation date : 15.05.1999
  5. **
  6. **      Description       :
  7. **         Standart 3d extension module for tdo.library.
  8. **         Loads and saves the mesh as RAW ASCII file.
  9. **
  10. **
  11. **      Written by Stephan Bielmann
  12. **
  13. */
  14.  
  15. /*************************** Includes *******************************/
  16.  
  17. /*
  18. ** Ansi C includes
  19. */
  20. #include <string.h>
  21.  
  22. /*
  23. ** Amiga includes
  24. */
  25. #include <dos/dos.h>
  26. #include <dos/stdio.h>
  27.  
  28. #include <clib/dos_protos.h>
  29. #include <clib/alib_stdio_protos.h>
  30.  
  31. /*
  32. ** Project includes
  33. */
  34. #include "tdo_public.h"
  35. #include "compiler.h"
  36. #include "tdo.h"
  37.  
  38. /**************************** Defines *******************************/
  39.  
  40. #define Ci_BUFFERS 100    // constant size of all used buffers in this mudule
  41.  
  42. /*********************** Type definitions ***************************/
  43.  
  44. typedef struct {
  45.     TTDOFloat x1,y1,z1,x2,y2,z2,x3,y3,z3;
  46. }RAWTriangle;
  47.  
  48. /*************************** Variables ******************************/
  49.  
  50. /********************** Private functions ***************************/
  51.  
  52. /********************** Public functions ****************************/
  53.  
  54. /****** geoa.library/tdo3XSave ******************************************
  55. * 
  56. *   NAME    
  57. *     tdo3XSave -- Saves the mesh as a 3D file.
  58. *
  59. *   SYNOPSIS
  60. *    error = tdo3XSave( meshhandle,filename,screen)
  61. *                       D1         D2        A0
  62. *
  63. *    ULONG tdo3XSave
  64. *         ( ULONG,STRPTR,struct Screen " );
  65. *
  66. *   FUNCTION
  67. *    The mesh will be saved in a 3 dimensional representation in the
  68. *    filename, without existence checks.
  69. *    The screen parameter is optional and only used if non-NULL, to
  70. *    display a window with additional or special parameters needed to
  71. *    save the mesh, or messages.
  72. * 
  73. *   INPUTS
  74. *     meshhandle    - A valid handle of a mesh.
  75. *    filename      - Name of the file to create.
  76. *    screen        - Pointer to the work screen.
  77. *    
  78. *   RESULT
  79. *     error - RCNOERROR      if all went well.
  80. *            RCNOTIMPL      if the function is not implemented.
  81. *            RCNOMEMORY     if there is not enough memory. 
  82. *            RCWRITEDATA    if an error occured while writing data, no more space.
  83. *            RCOVERFLOW     if the mesh is to extensive for this format.
  84. *            RCNOMATERIAL   if there are no materials, but they are expected.
  85. *           RCNOPART       if there are no parts, but they are expected.
  86. *            RCNOPOLYGON    if there are no polygons, but they are expected.
  87. *            RCNOVERTEX     if there are no vertices, but they are expected.
  88. *            IoErr()        if possible you will get this.
  89. *            tdo errors     if a tdo call failed.
  90. * 
  91. *   EXAMPLE
  92. *    error = tdo3XSave(meshhandle,"ram:test",NULL);
  93. *
  94. *   NOTES
  95. *    By setting the meshhandle to 0 the function returns RCNOERROR if
  96. *    it is implemented or RCNOTIMPL if not !
  97. *
  98. *   BUGS
  99. * 
  100. *   SEE ALSO
  101. * 
  102. ******************************************************************************
  103. *
  104. */
  105. ULONG __saveds ASM tdo3XSave(register __d1 ULONG meshhandle,
  106.                             register __d2 STRPTR filename,
  107.                             register __a0 struct Screen *screen) {
  108.  
  109.     BPTR            rawfile=NULL;
  110.     ULONG            mesh,nofv,nofpo,nofpa,i,j,n;
  111.     TTDOVertexf    v1,v2,v3;
  112.     RAWTriangle    tbuffer[Ci_BUFFERS]; // Ci_BUFFERS * sizeof(RAWTriangle)    triangle buffer
  113.     ULONG            bufferstate;
  114.  
  115.     mesh=meshhandle;
  116.  
  117.     // we were asked for implementation
  118.     if(mesh==0) {
  119.         return(RCNOERROR);
  120.     }
  121.  
  122.     // Ensure that no current polygon is set
  123.     meshPartPolygonEnd(mesh);
  124.  
  125.     nofv=meshNofVerticesGet(mesh);
  126.     nofpo=meshNofPolygonsGet(mesh);
  127.     nofpa=meshNofPartsGet(mesh);
  128.  
  129.     // Check if there are some vertices
  130.     if(nofv==0) {
  131.         return(RCNOVERTEX);
  132.     }
  133.  
  134.     // Check if there are some polygons
  135.     if(nofpo==0) {
  136.         return(RCNOPOLYGON);
  137.     }
  138.  
  139.     // Check if there are some parts
  140.     if(nofpa==0) {
  141.         return(RCNOPART);
  142.     }
  143.  
  144.     /* Open the file for output */
  145.     if((rawfile=Open(filename,MODE_NEWFILE))==NULL) return(IoErr());
  146.  
  147.     /* Change the buffer size of the filehandle to 10k */
  148.     if (SetVBuf(rawfile,NULL,BUF_FULL,10000)!=DOSFALSE) {
  149.         Close(rawfile);
  150.         return(RCNOMEMORY);
  151.     }
  152.  
  153.     // Write the header
  154.     if(FWrite(rawfile,"RAWB",4,1)!=1) {
  155.         Close(rawfile);
  156.         return(RCWRITEDATA);
  157.     }
  158.  
  159.     bufferstate=0;
  160.  
  161.     // Get all parts and write down theyr polygons with material
  162.     for(i=1;i<=nofpa;i++) {
  163.         if((nofpo=meshPartNofPolygonsGet(mesh,i))>0) {
  164.             for(j=1;j<=nofpo;j++) {
  165.                 meshPartPolygonCurrentSet(mesh,i,j);
  166.                 // we are saving triangles, so at least 3 vertices must be there
  167.  
  168.                 if((nofv=meshNofVerticesGet(mesh))>2) {
  169.                     meshVertexGetfv(mesh,1,&v1);
  170.  
  171.                     n=2;
  172.                     while(n<nofv) {
  173.  
  174.                         meshVertexGetfv(mesh,n++,&v2);
  175.                         meshVertexGetfv(mesh,n,&v3);
  176.  
  177.                         tbuffer[bufferstate].x1=v1.x;
  178.                         tbuffer[bufferstate].y1=v1.y;
  179.                         tbuffer[bufferstate].z1=v1.z;
  180.  
  181.                         tbuffer[bufferstate].x2=v2.x;
  182.                         tbuffer[bufferstate].y2=v2.y;
  183.                         tbuffer[bufferstate].z2=v2.z;
  184.  
  185.                         tbuffer[bufferstate].x3=v3.x;
  186.                         tbuffer[bufferstate].y3=v3.y;
  187.                         tbuffer[bufferstate].z3=v3.z;
  188.  
  189.                         // check if the buffer is full and write and initialize it
  190.                         if (++bufferstate==Ci_BUFFERS) {
  191.                             if(FWrite(rawfile,&tbuffer,Ci_BUFFERS*sizeof(RAWTriangle),1)!=1) {
  192.                                 Close(rawfile);
  193.                                 return(RCWRITEDATA);
  194.                             }
  195.                             bufferstate=0;
  196.                         }
  197.                     }
  198.                 }
  199.             }
  200.         }
  201.     }
  202.  
  203.     // check if the buffer has still some elements and write them
  204.     if (bufferstate>0) {
  205.         if(FWrite(rawfile,&tbuffer,bufferstate*sizeof(RAWTriangle),1)!=1) {
  206.             Close(rawfile);
  207.             return(RCWRITEDATA);
  208.         }
  209.         bufferstate=0;
  210.     }
  211.  
  212.     // Close the file
  213.     Close(rawfile);
  214.  
  215.     return(RCNOERROR);
  216. }
  217.  
  218. /****** geoa.library/tdo3XLoad ******************************************
  219. * 
  220. *   NAME    
  221. *     tdo3XLoad -- Load a 3D file and creates a mesh.
  222. *
  223. *   SYNOPSIS
  224. *    error = tdo3XLoad( meshhandle,filename,erroffset,screen)
  225. *                       D1         D2       D3         A0
  226. *
  227. *    ULONG tdo3XLoad
  228. *         ( ULONG,STRPTR,ULONG *,struct Screen " );
  229. *
  230. *   FUNCTION
  231. *    A file which contains a 3 dimensional representation
  232. *    will be examined for all known elements and converted into the
  233. *    mesh.
  234. *    The screen parameter is optional and only used if non-NULL, to
  235. *    display a window with additional or special parameters needed to
  236. *    save the mesh or messages.
  237. *    If an error occurs, erroffset contains the file offset in lines for
  238. *    ascii files and bytes for binary formats.
  239. * 
  240. *   INPUTS
  241. *     meshhandle    - A valid handle of a mesh.
  242. *    filename      - Name of the file to load.
  243. *    erroffset     - Offset where a read error occured.
  244. *    screen        - Pointer to the work screen.
  245. *    
  246. *   RESULT
  247. *     error - RCNOERROR       if all went well.
  248. *            RCNOTIMPL       if the function is not implemented.
  249. *            RCNOMEMORY      if there is not enough memory. 
  250. *            RCUNKNOWNFORMAT if the file format is unknown.
  251. *            RCNOFILE        if the file is not found.
  252. *            RCREADDATA      if an error occured while reading data.
  253. *            RCNOMATERIAL    if there are no materials, but they are expected.
  254. *           RCNOPART        if there are no parts, but they are expected.
  255. *            RCNOPOLYGON     if there are no polygons, but they are expected.
  256. *            RCNOVERTEX      if there are no vertices, but they are expected.
  257. *            IoErr()         if possible you will get this.
  258. *            tdo errors      if a tdo call failed.
  259. * 
  260. *   EXAMPLE
  261. *    error = tdo3XLoad(meshhandle,"ram:test",NULL);
  262. *
  263. *   NOTES
  264. *    By setting the meshhandle to 0 the function returns RCNOERROR if
  265. *    it is implemented or RCNOTIMPL if not !
  266. *
  267. *   BUGS
  268. * 
  269. *   SEE ALSO
  270. * 
  271. ******************************************************************************
  272. *
  273. */
  274. ULONG __saveds ASM tdo3XLoad(register __d1 ULONG meshhandle,
  275.                             register __d2 STRPTR filename,
  276.                             register __d3 ULONG *erroffset,
  277.                             register __a0 struct Screen *screen) {
  278.  
  279.     ULONG            mesh;
  280.     BPTR            rawfile=NULL;
  281.     UBYTE            header[5];
  282.     TTDOFloat        af[9];
  283.     TTDOColorub color;
  284.  
  285.  
  286.     mesh=meshhandle;
  287.  
  288.     // we were asked for implementation
  289.     if(mesh==0) {
  290.         return(RCNOERROR);
  291.     }
  292.  
  293.     // we have one white material and one part
  294.     meshMaterialAdd(mesh);
  295.     color.r=255,color.g=255,color.b=255;
  296.     meshMaterialDiffuseColorSetubc(mesh,1,&color);
  297.     meshPartAdd(mesh);
  298.     meshPartMaterialSet(mesh,1,1);
  299.     
  300.     // check if all went well
  301.     if(meshNofMaterialsGet(mesh)!=1 || meshNofPartsGet(mesh)!=1) {
  302.         return(RCNOMEMORY);
  303.     }
  304.  
  305.     /* Open the file for input */
  306.     if((rawfile=Open(filename,MODE_OLDFILE))==NULL) return(RCNOFILE);
  307.  
  308.     // initializing the offset counter
  309.     (*erroffset)=1;
  310.  
  311.     // Read the header
  312.     if(FRead(rawfile,header,4,1)!=1) {
  313.         Close(rawfile);
  314.         return(RCREADDATA);
  315.     }
  316.  
  317.     (*erroffset)+=4;
  318.  
  319.     if(strncmp(header,"RAWB",4)!=0) {
  320.         Close(rawfile);
  321.         return(RCUNKNOWNFORMAT);
  322.     }
  323.  
  324.     // ensure no current polygon
  325.     meshPartPolygonEnd(mesh);
  326.  
  327.     while(FRead(rawfile,af,sizeof(af),1)==1) {
  328.         meshPartTriangleAdd9fa(mesh,1,af);
  329.         (*erroffset)+=sizeof(af);
  330.     }
  331.     
  332.     return(RCNOERROR);
  333. }
  334.  
  335. /****** geoa.library/tdo3XCheckFile ******************************************
  336. * 
  337. *   NAME    
  338. *     tdo3XCheckFile -- Checks if the file is in the format we expected to load.
  339. *
  340. *   SYNOPSIS
  341. *    error = tdo3XLoad( filename )
  342. *                       D1
  343. *
  344. *    ULONG tdo3XCheckFile
  345. *         ( STRPTR );
  346. *
  347. *   FUNCTION
  348. *    The file its header will be examinated to verify if it is the
  349. *    file format we expect to read with the load function.
  350. * 
  351. *   INPUTS
  352. *    filename      - Name of the file to load.
  353. *    
  354. *   RESULT
  355. *     error - RCNOERROR       if all went well.
  356. *            RCUNKNOWNFORMAT if the file format is unknown.
  357. *            RCNOFILE        if the file is not found.
  358. *            RCREADDATA      if an error occured while reading data.
  359. *            IoErr()         if possible you will get this.
  360. * 
  361. *   EXAMPLE
  362. *    error = tdo3XCheckFile("ram:test");
  363. *
  364. *   NOTES
  365. *
  366. *   BUGS
  367. * 
  368. *   SEE ALSO
  369. * 
  370. ******************************************************************************
  371. *
  372. */
  373. ULONG __saveds ASM tdo3XCheckFile(register __d2 STRPTR filename) {
  374.  
  375.     BPTR    rawfile;
  376.     UBYTE    header[5];
  377.  
  378.     /* Open the file for input */
  379.     if((rawfile=Open(filename,MODE_OLDFILE))==NULL) return(RCNOFILE);
  380.  
  381.     // Read the header
  382.     if(FRead(rawfile,header,4,1)!=1) {
  383.         Close(rawfile);
  384.         return(RCREADDATA);
  385.     }
  386.  
  387.     Close(rawfile);
  388.  
  389.     if(strncmp(header,"RAWB",4)!=0) {
  390.         return(RCUNKNOWNFORMAT);
  391.     }
  392.  
  393.     return(RCNOERROR);
  394. }
  395.  
  396. /****** geoa.library/tdo3XExt ******************************************
  397. * 
  398. *   NAME    
  399. *     tdo3XExt -- Returns the default extension of the file format.
  400. *
  401. *   SYNOPSIS
  402. *    ext = tdo3XExt ( )
  403. *
  404. *    SRPTR tdo3XExt
  405. *         ( );
  406. *
  407. *   FUNCTION
  408. *    The default extension of the file format will be returned
  409. *    as READ_ONLY, NULL terminated string which will be only valid
  410. *    as long as the library is opened.
  411. * 
  412. *   INPUTS
  413. *    
  414. *   RESULT
  415. *     ext - String pointer to the extension, or NULL no default.
  416. * 
  417. *   EXAMPLE
  418. *    ext = tdo3XExt();
  419. *
  420. *   NOTES
  421. *
  422. *   BUGS
  423. * 
  424. *   SEE ALSO
  425. * 
  426. ******************************************************************************
  427. *
  428. */
  429. STRPTR __saveds ASM tdo3XExt () {
  430.     static STRPTR ext="raw";
  431.  
  432.     return(ext);
  433. }
  434.  
  435. /****** geoa.library/tdo3XName ******************************************
  436. * 
  437. *   NAME    
  438. *     tdo3XName -- Returns the file format name string.
  439. *
  440. *   SYNOPSIS
  441. *    name = tdo3XName ( )
  442. *
  443. *    SRPTR tdo3XName
  444. *         ( );
  445. *
  446. *   FUNCTION
  447. *    The file format its name will be returned. This string should not 
  448. *    be to large, about 20 characters maximum.
  449. *    The string is READ_ONLY, NULL terminated and only valid as
  450. *    long as the library is opened.
  451. * 
  452. *   INPUTS
  453. *    
  454. *   RESULT
  455. *     name - String pointer to the name, or NULL no one.
  456. * 
  457. *   EXAMPLE
  458. *    name = tdo3XName();
  459. *
  460. *   NOTES
  461. *
  462. *   BUGS
  463. * 
  464. *   SEE ALSO
  465. * 
  466. ******************************************************************************
  467. *
  468. */
  469. STRPTR __saveds ASM tdo3XName () {
  470.     static STRPTR name="TDO RAW binary";
  471.  
  472.     return(name);
  473. }
  474.  
  475. /************************* End of file ******************************/
  476.